COMMENT ⊗   VALID 00009 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	This demo is to introduce new users to the RLL system.
C00005 00003		Start Up and Look See
C00009 00004		Geneology
C00012 00005	[On to Geneology]
C00015 00006		More parentage
C00016 00007		Rearranging hierarchy
C00017 00008		Other things
C00018 00009		Back to probing
C00020 ENDMK
C⊗;
This demo is to introduce new users to the RLL system.
[10 August 1981]

Theme: To everything, a unit.

Overhead:
RLL does well at:
1. Functions - from processes, to slots.  well incorporated
	(these will probably be carried over to next systems...)
2. Unit initialization -- still more thinking, but framework present.
3. KB consistency -- ties in Caching, Cognitive Economy

RLL's current failings:
1. Many unsightly clumps of LISP code
2. Much of this is in LISP functions, not (yet) unit-zed

Meta comments:
	Please feel free to ask questions at any time.
	Also, I'd appreciate feedback at the end, offering suggestions
for how to improve this sort of thing for next time.
In particular, which (painfully obvious) parts did I belabor; and where were
you just totally snowed.
What should the prerequesites for this demo be?

----
Final notes:
(1) current problem with CORLL -- it doesn't bump often enough.
(IE only when free space FALLS below some threshold -- but once there,
does nothing.  We know the problem, and perhaps the solution... but not
before doing a demo.)

(2) Realize the FIRST time a given action is taken it will be slow.  
This is intensional -- RLL has to do a lot of work to write
the necessary functions, etc, from more basic primitives.
These values (eg functions, and reusable partial results of computations)
are then often cached away, speeding up subsequent performance.
	Start Up and Look See

(Start up RLL from the monitor level -- thru CORLL, reading in KBs...)

DI(Anything S 4)
	- most elaborated part are processes - from processes thru ...
	- note view of slots as functions

DI(Anything S 4)
	- note faster this time - as stuff
		(from defn of SubClass* to actual stored values, have been cached)
	[Later show # of CONS's are way down]
   <<<Explain that starting system is devoid of many "virtual" - ie redundant -
	slots.  These are now generated, and cached for future speed up. >>>

EU AnySlot
	- InterLisp editor - with a few of my bells-and-whistles
	- Recursion
	  - Show SubClass's, and TypicalExample (PPU)
	- Changes can be made, and updates as appropriate

EU RussGreiner	[or RLL.STATUS, UNION, PutValue]
	- weak version of user profile
		[Recall RLL suggested my standard files and options]
	- Note Isa, MyIsa --
		   <<< Convention: My... are SYNTACTIC! >>>
	- Go up to AnyUser, then to TypicalUser
		Show defaults 
	- Note absense of AllIsas slot.

  (To show new values being automatically derived and cached)

AllIsas(RussGreiner)
	- Recall RussGreiner did NOT have an AllIsas property before;
	  but does now
	- Note there is no AllIsas function 
		[done using a general hack (for all processes) to interpreter]

   <<< Here draw picture of AnyX, to Examples x-i; and to TypicalExample TypicalX;
	and to SubClass AnyY, AnyZ, ...; and to SuperClass AnyA, AnyB ...
	where each of these classes also have (specific) examples 
	and a TypicalExample.  Of course EPSILON is on up these super-classes... >>>

EU TypicalStatus
	- Note MyIsa includes AnyTypicalExample,
	  while it itself Isa member of AnyStatus.
	- Examine MyNewPossibleSlots here

(this leads to:)

NewKB(DEMO)
	- Show new unit, DEMO.STATUS
		[Some slots (Isa) initialized;
		 others (Networks*) can get values as needed.]
	- Or both: Delete value of KBsFNS, then regenerate it from more primitive

RLL-LIST(DEMO)

UF.NETWORKS

  === Pause for Questions ===
	Geneology

NewSubClass(AnyPerson Anything)

NewTypEx(TypicalPerson)
  [Before leaving, show PossibleSlotsOfIExamples - note no StoredAValue]
	- Note we could have AnyMan & AnyWoman; with different slots.
		[both under AnyPerson] -- but for now, no.
		Can switch later.
    <<< Observe successive new slot are generated faster -
	thanks to PSofIE again; now including a cached value. >>>

  - MyNewPossibleSlots: Gender, Husband, Wife, Mother, Kids, #Hands
	- Gender - Primitive
		Format: FSingleton
		DataRange: (*OneOf Male Female)
		[Leave Datatype]
	  [Note: Could have GenderType -- maybe later]
	- Husband - Primitive 
		RangeType: (FSingleton (UnitType (L-AND (*P AnyPerson)
					(*SlotVal Gender Male)))) ...
		DomainType: (FSingleton (UnitType (L-AND (*P AnyPerson)
					(*SlotVal Gender Female)))) ...
	- Wife - * Husband
		change Female <=> Male
		Inverse: Husband
	- Mother - * Wife
		simplify DomainType
	- Kids - Primitive
		DataRange: (*P AnyPerson)
		Inverse: Mother
		[Let it ask about Format]
	- #Hands - Inheritable
		RangeType: (FSingleton Integer)
		Copy Mother DomainType

    <<<WRT Inverse: later may show how certain limitations of this, and then
		how this was solved. >>>

--- Comments ---
These new slots hold almost nothing - just framework.
We'll fill them in later.

[On to Geneology]

NewIsa(Steve (AnyPerson))
	- Again, this first person will be slow.
	- Gender:Male

#Hands(Steve)	← 2, as inherited

Wife(Steve)	← NoEntry  (as none given)
	[Note value not cached, as CacheIfOk. ]

EU Wife
	- Change ToCacheValue ← DefaultCacheValue
Wife(Steve)	← NoEntry  (now value is cached)

Husband(Steve)	← u.d.f. as type error

NewIsa(Momma)
	- faster than Steve
	- Gender: Female  [need this, or can't have kids)
	- Kids: (Steve)

NewIsa(Hubby)
	- Gender: Male
	- Wife: Momma

NewIsa(Father AnyComputableSlot)
	- Give it a HighLevelDefn = (Composition Husband Mother)
	- MakesSenseFor = (TypicalPerson)
   <<< Note PSofIE has StoredAValue for (AnyPerson). This was used for creating...)

EU PossibleSlotsofIExamples
	- now nothing for (AnyPerson) anymore.  Really indirect, from Father
	[Quickly show KBUpdates for MyNewPossibleSlots,
	 and mention its derivation from CVUsedBy.]

Father(Steve)
	- Note Father has been stashed

NewIsa(Hub2)
	- Set Wife to Momma
	- This will reset Husband of Momma (note it squacks!)

EU FSingleton
	- Quick mention - here is where squack occurred
	- We could turn this off... note fix is HERE 
		<<< just one spot for everything using FSingleton >>>
		<<< If we go to uniform MRS type system, here we could twiddle
		    FnForPutting and FnForGetting, etc, to include, say SET... >>>

EU Hubby
	- show no Wife

EU Steve
	- Note Father removed!

Father(Steve)
	- does the right thing now.
	- One time cost.

	More parentage

Create Parents
AddValue(TypicalPerson MyNewPossibleSlots Parents)
	- show it getting added.
  for Parents:HLD = (Unioning Mother Father)
 (Now PSofIE is changed, as is SteveKlein:MySensibleSlots)

Parents(Steve)

 --- SubTheme: Cognitive Economy -- you have the values you want, when
	you want them.  Only one time expense. ---

AddValue(TypicalPerson MyNewPossibleSlots Aunt)
  for Aunt:HLD = (Unioning (Composition Sister Parents)
			   (Composition Wife Brother Parents))

	- we could now sort these by Wealth, but only additional hassle -

  === Pause for Questions ===
	Rearranging hierarchy

 (Make all Persons Users)
InformalName(Steve) - u.d.f., type error

EU AnyPerson
	- Change SuperClass to (AnyUser)

	- Show that Steve now has new set of slots)
	- Also PSofIE has been changed again -- maybe:
	Note the changes don't go thru uncached values, as too expensive
		(could be twiddled to, but ...)

 --- Note this would have been virtually IMPOSSIBLE in MJS's UNITs System ---

InformalName(Steve) - now works

Change Momma to be an AnyUser
	Note Gender now irrlevant, and discarded
	- Steve now loses his Mother, Father, ...

	Other things
There are Units for
 * Format
 * Datatypes
 * Classes
 * Slots
 * Inheritances
 * Some functions - eg MapUnion
 * Slot combiners - even Functional for generating sc's!

Info for things like
  When deleting a slot, or a class
  Or when renaming -- there are special case

	Back to probing
 (Can put special info to direct Get, Put, ...)

Let's look at the functions:
	- GetValue
	- PutValue (AddValue, DeleteValue, SubstValue)
	- FNewUnit

Smarts are, well, look on

EU TypicalSlot
	- Note the ToGetValue, ToPutValue, ...

Consider Isa - with its special AfterPutValue
	(Sorry, not yet a unit.)